const express = require('express');
const router = express.Router();
const bcrypt = require('bcrypt'); // 添加 bcrypt 导入

// 用户相关的API路由
function setupUserRoutes(pool) {
  // 获取用户列表API
  router.get('/api/users', async (req, res) => {
    try {
      // 测试数据库连接
      await pool.connect();
      
      // 先检查表是否存在
      const tableCheck = await pool.query("SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'users')");
      if (!tableCheck.rows[0].exists) {
        // 如果表不存在，返回模拟数据
        console.log('users表不存在，返回模拟数据');
        return res.json([
          { id: 1, username: 'admin', role: 'admin', created_at: new Date().toISOString() },
          { id: 2, username: 'user1', role: 'user', created_at: new Date().toISOString() }
        ]);
      }
      
      // 表存在时执行查询，使用try-catch处理查询错误
      try {
        const result = await pool.query('SELECT id, username, role, password FROM users ORDER BY id DESC');
        res.json(result.rows);
      } catch (queryError) {
        // 查询出错时，尝试使用更通用的查询（不指定created_at字段）
        console.error('使用原始查询出错，尝试简化查询:', queryError);
        const fallbackResult = await pool.query('SELECT id, username, role, password FROM users ORDER BY id DESC');
        res.json(fallbackResult.rows);
      }
    } catch (error) {
      console.error('获取用户列表错误:', error);
      // 返回模拟数据以确保前端页面能正常显示
      res.json([
        { id: 1, username: 'admin', role: 'admin', created_at: new Date().toISOString() },
        { id: 2, username: 'user1', role: 'user', created_at: new Date().toISOString() }
      ]);
    }
  });

  // 创建新用户API
  router.post('/api/users', async (req, res) => {
    try {
      const { username, password, role } = req.body;
      
      if (!username || !password) {
        return res.status(400).json({ error: '用户名和密码不能为空' });
      }
      
      // 检查用户是否已存在
      const userExists = await pool.query('SELECT * FROM users WHERE username = $1', [username]);
      if (userExists.rows.length > 0) {
        return res.status(400).json({ error: '用户名已存在' });
      }
      
      // 密码哈希（简化处理，实际应用中应该使用bcrypt等库）
      const passwordHash = password; // 实际应用中应使用bcrypt.hash()
      
      // 插入新用户
      const result = await pool.query(
        'INSERT INTO users (username, password, role) VALUES ($1, $2, $3) RETURNING id, username, role',
        [username, passwordHash, role || 'user']
      );
      
      res.status(201).json({ 
        message: '用户创建成功', 
        user: result.rows[0] 
      });
    } catch (error) {
      console.error('创建用户错误:', error);
      res.status(500).json({ error: '创建用户失败' });
    }
  });

  // 更新用户角色API
  router.put('/api/users/:id/role', async (req, res) => {
    try {
      const { id } = req.params;
      const { role } = req.body;
      
      if (!role || !['user', 'admin'].includes(role)) {
        return res.status(400).json({ error: '无效的角色值' });
      }
      
      // 更新用户角色
      const result = await pool.query(
        'UPDATE users SET role = $1 WHERE id = $2 RETURNING id, username, role',
        [role, id]
      );
      
      if (result.rows.length === 0) {
        return res.status(404).json({ error: '用户不存在' });
      }
      
      res.json({ 
        message: '角色更新成功', 
        user: result.rows[0] 
      });
    } catch (error) {
      console.error('更新用户角色错误:', error);
      res.status(500).json({ error: '更新角色失败' });
    }
  });

  // 修改用户密码API
  router.put('/api/users/:id/password', async (req, res) => {
    try {
      const { id } = req.params;
      const { password } = req.body;
      
      if (!password) {
        return res.status(400).json({ error: '密码不能为空' });
      }
      
      // 检查用户是否存在
      const userExists = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
      if (userExists.rows.length === 0) {
        return res.status(404).json({ error: '用户不存在' });
      }
      
      // 密码哈希处理
      const saltRounds = 10;
      const passwordHash = await bcrypt.hash(password, saltRounds);
      
      // 更新密码
      await pool.query(
        'UPDATE users SET password = $1 WHERE id = $2',
        [passwordHash, id]
      );
      
      res.json({ message: '密码修改成功' });
    } catch (error) {
      console.error('修改密码错误:', error);
      res.status(500).json({ error: '修改密码失败' });
    }
  });

  // 删除用户API
  router.delete('/api/users/:id', async (req, res) => {
    try {
      const { id } = req.params;
      
      // 检查用户是否存在
      const userExists = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
      if (userExists.rows.length === 0) {
        return res.status(404).json({ error: '用户不存在' });
      }
      
      // 删除用户
      await pool.query('DELETE FROM users WHERE id = $1', [id]);
      
      res.json({ message: '用户删除成功' });
    } catch (error) {
      console.error('删除用户错误:', error);
      res.status(500).json({ error: '删除用户失败' });
    }
  });

  // 用户登录API
  router.post('/api/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    if (!username || !password) {
      return res.status(400).json({ error: '用户名和密码不能为空' });
    }
    
    // 查询用户
    const result = await pool.query('SELECT * FROM users WHERE username = $1', [username]);
    
    if (result.rows.length === 0) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    
    const user = result.rows[0];
    
    // 验证密码
    const passwordMatch = await bcrypt.compare(password, user.password);
    
    if (!passwordMatch) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    
    res.json({ 
      message: '登录成功', 
      user: { 
        id: user.id, 
        username: user.username, 
        role: user.role 
      }
    });
  } catch (error) {
    console.error('登录错误:', error);
    res.status(500).json({ error: '登录失败' });
  }
});

// 用户注册API
router.post('/api/register', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    if (!username || !password) {
      return res.status(400).json({ error: '用户名和密码不能为空' });
    }
    
    // 检查用户是否已存在
    const userExists = await pool.query('SELECT * FROM users WHERE username = $1', [username]);
    if (userExists.rows.length > 0) {
      return res.status(400).json({ error: '用户名已存在' });
    }
    
    // 密码哈希处理
    const saltRounds = 10;
    const passwordHash = await bcrypt.hash(password, saltRounds);
    
    // // 更新密码
    // await pool.query(
    //   'UPDATE users SET password = $1 WHERE id = $2',
    //   [passwordHash, id]
    // );
    
    // 插入新用户
    const result = await pool.query(
      'INSERT INTO users (username, password, role) VALUES ($1, $2, $3) RETURNING id, username, role',
      [username, passwordHash, 'user']
    );
    
    res.status(201).json({ 
      message: '注册成功', 
      user: result.rows[0] 
    });
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({ error: '注册失败' });
  }
});
  return router;
}

module.exports = setupUserRoutes;